// Background script for bookmark export functionality and browsing history storage

// 存储浏览历史数据
let browsingHistory = [];
let collectEnabled = false; // 默认禁用数据收集

// 导航服务地址
const SERVER_URL = 'http://localhost:8080';

// 监听存储变化，更新数据收集状态
chrome.storage.sync.onChanged.addListener((changes, namespace) => {
  if (namespace === 'sync' && changes.collectEnabled) {
    collectEnabled = changes.collectEnabled.newValue;
    console.log('数据收集状态已更新:', collectEnabled ? '启用' : '禁用');
  }
});

// 初始化时获取数据收集状态
chrome.storage.sync.get(['collectEnabled'], function(result) {
  collectEnabled = result.collectEnabled || false;
  console.log('初始数据收集状态:', collectEnabled ? '启用' : '禁用');
});

// 监听来自popup的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  // 处理来自content script的浏览数据
  if (request.action === "addBrowsingData") {
    // 检查数据收集是否启用
    if (!collectEnabled) {
      sendResponse({status: "success", message: "数据收集已禁用"});
      return true;
    }
    
    const pageData = request.data;
    // 添加到浏览历史
    browsingHistory.push(pageData);
    
    // 保留最近1000条记录
    if (browsingHistory.length > 1000) {
      browsingHistory.shift();
    }
    
    // 同时保存到Chrome存储中，以便持久化
    chrome.storage.local.set({browsingHistory: browsingHistory}, function() {
      if (chrome.runtime.lastError) {
        console.error("保存浏览历史到存储时出错:", chrome.runtime.lastError);
      }
    });
    
    sendResponse({status: "success"});
    return true;
  }
  // 处理导出书签的请求
  else if (request.action === "exportBookmarks") {
    exportBookmarks().then((bookmarks) => {
      if (bookmarks) {
        sendResponse({data: bookmarks});
      } else {
        sendResponse({data: null});
      }
    }).catch((error) => {
      console.error("导出书签时出错:", error);
      sendResponse({data: null, error: error.message});
    });
    return true; // 保持消息通道开放以进行异步响应
  }
  // 处理导出浏览历史的请求
  else if (request.action === "exportHistory") {
    // 检查数据收集是否启用
    if (!collectEnabled) {
      sendResponse({data: [], message: "数据收集已禁用"});
      return true;
    }
    
    // 从存储中获取最新的浏览历史
    chrome.storage.local.get(['browsingHistory'], function(result) {
      if (chrome.runtime.lastError) {
        console.error("获取浏览历史时出错:", chrome.runtime.lastError);
        sendResponse({data: []});
        return;
      }
      
      const history = result.browsingHistory || browsingHistory || [];
      sendResponse({data: history});
    });
    return true; // 保持消息通道开放以进行异步响应
  }
  // 处理同步浏览历史的请求
  else if (request.action === "syncHistory") {
    syncBrowsingHistory().then((result) => {
      sendResponse(result);
    }).catch((error) => {
      console.error("同步浏览历史时出错:", error);
      sendResponse({status: "error", message: `同步失败: ${error.message}`});
    });
    return true; // 保持消息通道开放以进行异步响应
  }
  // 处理同步书签的请求
  else if (request.action === "syncBookmarks") {
    syncBookmarks().then((result) => {
      sendResponse(result);
    }).catch((error) => {
      console.error("同步书签时出错:", error);
      sendResponse({status: "error", message: `同步失败: ${error.message}`});
    });
    return true; // 保持消息通道开放以进行异步响应
  }
  // 处理上传书签到浏览器的请求
  else if (request.action === "uploadBookmarks") {
    uploadBookmarksToBrowser().then((result) => {
      sendResponse(result);
    }).catch((error) => {
      console.error("上传书签到浏览器时出错:", error);
      sendResponse({status: "error", message: `上传失败: ${error.message}`});
    });
    return true; // 保持消息通道开放以进行异步响应
  }
});

// 监听标签页更新事件
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  // 检查数据收集是否启用
  if (!collectEnabled) {
    return;
  }
  
  // 当页面加载完成时收集数据
  if (changeInfo.status === 'complete' && tab.url) {
    // 过滤掉特殊页面
    if (tab.url.startsWith('http') || tab.url.startsWith('https')) {
      const pageData = {
        url: tab.url,
        title: tab.title || '',
        visitTime: new Date().toISOString(),
        domain: new URL(tab.url).hostname,
        path: new URL(tab.url).pathname
      };
      
      // 添加到浏览历史
      browsingHistory.push(pageData);
      
      // 保留最近1000条记录
      if (browsingHistory.length > 1000) {
        browsingHistory.shift();
      }
      
      // 同时保存到Chrome存储中，以便持久化
      chrome.storage.local.set({browsingHistory: browsingHistory}, function() {
        if (chrome.runtime.lastError) {
          console.error("保存浏览历史到存储时出错:", chrome.runtime.lastError);
        }
      });
      
      console.log('收集页面数据:', pageData);
    }
  }
});

// 同步浏览历史到服务器
async function syncBrowsingHistory() {
  try {
    // 检查数据收集是否启用
    if (!collectEnabled) {
      return {status: "success", message: "数据收集已禁用，无法同步"};
    }
    
    // 从存储中获取浏览历史
    const result = await new Promise((resolve) => {
      chrome.storage.local.get(['browsingHistory'], function(data) {
        resolve(data.browsingHistory || browsingHistory || []);
      });
    });
    
    if (result.length === 0) {
      return {status: "success", message: "没有浏览历史数据需要同步"};
    }
    
    // 发送到服务器
    const response = await fetch(`${SERVER_URL}/api/browsing-history`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        visits: result
      })
    });
    
    if (response.ok) {
      // 同步成功后清空本地数据
      browsingHistory = [];
      chrome.storage.local.set({browsingHistory: []}, function() {
        if (chrome.runtime.lastError) {
          console.error("清空浏览历史时出错:", chrome.runtime.lastError);
        }
      });
      
      return {status: "success", message: `成功同步 ${result.length} 条浏览历史记录`};
    } else {
      return {status: "error", message: `同步失败: ${response.status} ${response.statusText}`};
    }
  } catch (error) {
    console.error('同步浏览历史时出错:', error);
    throw error;
  }
}

// 同步书签到服务器
async function syncBookmarks() {
  try {
    // 检查数据收集是否启用
    if (!collectEnabled) {
      return {status: "success", message: "数据收集已禁用，无法同步"};
    }
    
    // 获取书签数据
    const bookmarks = await new Promise((resolve) => {
      chrome.bookmarks.getTree(function(bookmarkTreeNodes) {
        const bookmarks = [];
        
        // 递归遍历书签树
        function traverseBookmarks(bookmarkNodes, parentId = "0") {
          for (let i = 0; i < bookmarkNodes.length; i++) {
            const node = bookmarkNodes[i];
            if (node.url) {
              // 这是一个书签
              bookmarks.push({
                id: node.id,
                title: node.title,
                url: node.url,
                dateAdded: new Date(node.dateAdded).toISOString(),
                parentId: parentId
              });
            }
            if (node.children) {
              // 这是一个文件夹，继续遍历子节点
              traverseBookmarks(node.children, node.id);
            }
          }
        }
        
        traverseBookmarks(bookmarkTreeNodes);
        resolve(bookmarks);
      });
    });
    
    if (bookmarks.length === 0) {
      return {status: "success", message: "没有书签数据需要同步"};
    }
    
    // 发送到服务器
    const response = await fetch(`${SERVER_URL}/api/bookmarks`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(bookmarks)
    });
    
    if (response.ok) {
      return {status: "success", message: `成功同步 ${bookmarks.length} 个书签`};
    } else {
      return {status: "error", message: `同步失败: ${response.status} ${response.statusText}`};
    }
  } catch (error) {
    console.error('同步书签时出错:', error);
    throw error;
  }
}

// 从服务器获取书签并上传到浏览器
async function uploadBookmarksToBrowser() {
  try {
    console.log("开始上传书签到浏览器");
    
    // 从服务器获取导航数据
    const response = await fetch(`${SERVER_URL}/api/navigation`);
    
    if (!response.ok) {
      throw new Error(`获取导航数据失败: ${response.status} ${response.statusText}`);
    }
    
    const data = await response.json();
    
    if (data.code !== 200) {
      throw new Error(`获取导航数据失败: ${data.message}`);
    }
    
    const navigationData = data.data;
    console.log("获取到导航数据:", navigationData);
    
    // 创建根文件夹
    const rootFolder = await new Promise((resolve, reject) => {
      chrome.bookmarks.create({
        title: "个人导航书签"
      }, (result) => {
        if (chrome.runtime.lastError) {
          reject(new Error(chrome.runtime.lastError.message));
        } else {
          resolve(result);
        }
      });
    });
    
    console.log("创建根文件夹:", rootFolder);
    
    // 遍历分类并创建书签
    let bookmarkCount = 0;
    for (const category of navigationData.categories) {
      try {
        // 为每个分类创建文件夹
        const categoryFolder = await new Promise((resolve, reject) => {
          chrome.bookmarks.create({
            parentId: rootFolder.id,
            title: category.name
          }, (result) => {
            if (chrome.runtime.lastError) {
              reject(new Error(chrome.runtime.lastError.message));
            } else {
              resolve(result);
            }
          });
        });
        
        console.log(`创建分类文件夹 ${category.name}:`, categoryFolder);
        
        // 为分类中的每个项目创建书签
        for (const item of category.items) {
          try {
            await new Promise((resolve, reject) => {
              chrome.bookmarks.create({
                parentId: categoryFolder.id,
                title: item.name,
                url: item.url
              }, (result) => {
                if (chrome.runtime.lastError) {
                  reject(new Error(chrome.runtime.lastError.message));
                } else {
                  resolve(result);
                }
              });
            });
            bookmarkCount++;
            console.log(`创建书签: ${item.name} - ${item.url}`);
          } catch (itemError) {
            console.error(`创建书签失败 ${item.name}:`, itemError);
            // 继续处理下一个项目，不中断整个过程
          }
        }
      } catch (categoryError) {
        console.error(`处理分类失败 ${category.name}:`, categoryError);
        // 继续处理下一个分类，不中断整个过程
      }
    }
    
    console.log(`上传完成，共创建 ${bookmarkCount} 个书签`);
    return {status: "success", message: `成功上传 ${bookmarkCount} 个书签到浏览器`};
  } catch (error) {
    console.error('上传书签到浏览器时出错:', error);
    throw error;
  }
}

// 导出书签数据
async function exportBookmarks() {
  try {
    // 使用Chrome书签API获取书签数据
    return new Promise((resolve, reject) => {
      chrome.bookmarks.getTree(function(bookmarkTreeNodes) {
        try {
          const bookmarks = [];
          
          // 递归遍历书签树
          function traverseBookmarks(bookmarkNodes, parentId = "0") {
            for (let i = 0; i < bookmarkNodes.length; i++) {
              const node = bookmarkNodes[i];
              if (node.url) {
                // 这是一个书签
                bookmarks.push({
                  id: node.id,
                  title: node.title,
                  url: node.url,
                  dateAdded: new Date(node.dateAdded).toISOString(),
                  parentId: parentId
                });
              }
              if (node.children) {
                // 这是一个文件夹，继续遍历子节点
                traverseBookmarks(node.children, node.id);
              }
            }
          }
          
          traverseBookmarks(bookmarkTreeNodes);
          resolve(bookmarks);
        } catch (error) {
          reject(error);
        }
      });
    });
  } catch (error) {
    console.error('导出书签时出错:', error);
    throw error;
  }
}